#!/usr/bin/env node

import { execSync } from 'node:child_process'
import fs from 'node:fs'
import path from 'node:path'

/**
 * 自动修复 Electron 和 better-sqlite3 安装问题的 postinstall 脚本
 *
 * 功能：
 * 1. 自动配置代理设置（如果需要）
 * 2. 检测并修复 Electron 二进制文件安装
 * 3. 检测并修复 better-sqlite3 原生模块编译
 * 4. 确保一次 install 解决所有问题
 */

// 导入代理配置
let PROXY_CONFIG
try {
  const { PROXY_CONFIG: config } = await import('./proxy-config.js')
  PROXY_CONFIG = config
} catch {
  // 如果配置文件不存在，使用默认配置
  console.log('⚠️  未找到代理配置文件，使用默认配置')
  PROXY_CONFIG = {
    enabled: true,
    http: 'http://127.0.0.1:7890',
    https: 'http://127.0.0.1:7890',
    configureGit: true,
    configurePnpm: true,
    configureElectronMirror: true,
    electronMirror: 'https://npmmirror.com/mirrors/electron/'
  }
}

console.log('🚀 开始依赖安装后处理...')

/**
 * 配置代理设置
 */
function configureProxy() {
  if (!PROXY_CONFIG.enabled) {
    console.log('📡 代理配置已禁用，跳过代理设置')
    return
  }

  console.log('📡 配置代理设置...')

  try {
    // 配置 Git 代理
    if (PROXY_CONFIG.configureGit) {
      execSync(`git config --global http.proxy ${PROXY_CONFIG.http}`, { stdio: 'ignore' })
      execSync(`git config --global https.proxy ${PROXY_CONFIG.https}`, { stdio: 'ignore' })
      console.log('  ✓ Git 代理配置完成')
    }

    // 配置 pnpm 代理
    if (PROXY_CONFIG.configurePnpm) {
      execSync(`pnpm config set proxy ${PROXY_CONFIG.http}`, { stdio: 'ignore' })
      execSync(`pnpm config set https-proxy ${PROXY_CONFIG.https}`, { stdio: 'ignore' })
      console.log('  ✓ pnpm 代理配置完成')
    }

    // 配置 Electron 镜像
    if (PROXY_CONFIG.configureElectronMirror && PROXY_CONFIG.electronMirror) {
      execSync(`pnpm config set electron_mirror ${PROXY_CONFIG.electronMirror}`, {
        stdio: 'ignore'
      })
      console.log('  ✓ Electron 镜像配置完成')
    }

    console.log('✅ 代理配置完成')
  } catch (error) {
    console.log('⚠️  代理配置失败，但继续执行:', error.message)
  }
}

// 查找 electron 包的路径
function findElectronPath() {
  // 首先检查标准 node_modules 路径
  const standardPath = 'node_modules/electron'
  if (fs.existsSync(standardPath)) {
    try {
      // 检查是否是符号链接，如果是则解析真实路径
      const stats = fs.lstatSync(standardPath)
      if (stats.isSymbolicLink()) {
        const realPath = fs.realpathSync(standardPath)
        console.log(`🔍 解析符号链接: ${standardPath} -> ${realPath}`)
        return realPath
      }
      return standardPath
    } catch (error) {
      console.warn('⚠️  无法解析符号链接:', error.message)
      return standardPath
    }
  }

  // 然后查找 pnpm 目录
  try {
    const pnpmDir = 'node_modules/.pnpm'
    if (fs.existsSync(pnpmDir)) {
      const dirs = fs.readdirSync(pnpmDir)
      const electronDir = dirs.find(dir => dir.startsWith('electron@'))
      if (electronDir) {
        const electronPath = path.join(pnpmDir, electronDir, 'node_modules/electron')
        console.log(`🔍 找到 pnpm electron 路径: ${electronPath}`)
        return electronPath
      }
    }
  } catch (error) {
    console.warn('⚠️  无法扫描 .pnpm 目录:', error.message)
  }

  return null
}

// 检查 electron 是否正确安装
function isElectronInstalled(electronPath) {
  if (!electronPath || !fs.existsSync(electronPath)) {
    return false
  }

  const pathTxtFile = path.join(electronPath, 'path.txt')
  const distDir = path.join(electronPath, 'dist')

  // 检查关键文件是否存在
  if (!fs.existsSync(pathTxtFile) || !fs.existsSync(distDir)) {
    return false
  }

  // 检查 dist 目录是否有内容
  try {
    const distContents = fs.readdirSync(distDir)
    return distContents.length > 0
  } catch {
    return false
  }
}

// 运行 electron 安装脚本
function installElectron(electronPath) {
  const installScript = path.join(electronPath, 'install.js')

  if (!fs.existsSync(installScript)) {
    console.error('❌ 找不到 electron 安装脚本:', installScript)
    return false
  }

  try {
    console.log('📦 正在下载 Electron 二进制文件...')
    console.log('   这可能需要几分钟时间，请耐心等待...')

    // 设置环境变量以使用代理
    const env = { ...process.env }
    if (PROXY_CONFIG.enabled) {
      env.ELECTRON_GET_USE_PROXY = 'true'
      env.GLOBAL_AGENT_HTTP_PROXY = PROXY_CONFIG.http
      env.GLOBAL_AGENT_HTTPS_PROXY = PROXY_CONFIG.https
    }

    // 运行安装脚本
    execSync(`node "${installScript}"`, {
      cwd: electronPath,
      stdio: 'inherit',
      timeout: 300_000, // 5分钟超时
      env
    })

    console.log('✅ Electron 安装完成!')
    return true
  } catch (error) {
    console.error('❌ Electron 安装失败:', error.message)
    return false
  }
}

// 查找 realm 包的路径
function findRealmPath() {
  const standardPath = 'node_modules/realm'
  if (fs.existsSync(standardPath)) {
    try {
      const stats = fs.lstatSync(standardPath)
      if (stats.isSymbolicLink()) {
        const realPath = fs.realpathSync(standardPath)
        console.log(`🔍 解析符号链接: ${standardPath} -> ${realPath}`)
        return realPath
      }
      return standardPath
    } catch (error) {
      console.warn('⚠️  无法解析符号链接:', error.message)
      return standardPath
    }
  }

  try {
    const pnpmDir = 'node_modules/.pnpm'
    if (fs.existsSync(pnpmDir)) {
      const dirs = fs.readdirSync(pnpmDir)
      const realmDir = dirs.find(dir => dir.startsWith('realm@'))
      if (realmDir) {
        const realmPath = path.join(pnpmDir, realmDir, 'node_modules/realm')
        console.log(`🔍 找到 pnpm realm 路径: ${realmPath}`)
        return realmPath
      }
    }
  } catch (error) {
    console.warn('⚠️  无法扫描 .pnpm 目录:', error.message)
  }
  return null
}

// 检查 realm 是否已有 Electron 预编译二进制
function isRealmReadyForElectron(realmPath) {
  if (!realmPath || !fs.existsSync(realmPath)) return false
  const prebuildsDir = path.join(realmPath, 'prebuilds')
  if (!fs.existsSync(prebuildsDir)) return false

  // 如果存在 electron 目录，默认视为已就绪
  const electronDir = path.join(prebuildsDir, 'electron')
  if (fs.existsSync(electronDir)) return true

  // 一些版本在 prebuilds 下直接放置了 electron-v* 子目录
  try {
    const entries = fs.readdirSync(prebuildsDir)
    return entries.some(n => /^electron[-_]?v\d+/i.test(n))
  } catch {
    return false
  }
}

// 针对 Electron 重建（或下载预编译）Realm
function rebuildRealmForElectron(realmPath) {
  try {
    console.log('🔨 正在为 Electron 准备 Realm 原生模块...')

    const env = { ...process.env }
    if (PROXY_CONFIG.enabled) {
      env.HTTP_PROXY = PROXY_CONFIG.http
      env.HTTPS_PROXY = PROXY_CONFIG.https
      env.ELECTRON_GET_USE_PROXY = 'true'
      env.GLOBAL_AGENT_HTTP_PROXY = PROXY_CONFIG.http
      env.GLOBAL_AGENT_HTTPS_PROXY = PROXY_CONFIG.https
    }

    // 优先使用 electron-rebuild 只重建 realm
    try {
      console.log('🔄 使用 @electron/rebuild 重建 realm ...')
      execSync('npx @electron/rebuild -f -w realm', {
        cwd: process.cwd(),
        stdio: 'inherit',
        timeout: 600_000,
        env
      })
      console.log('✅ realm 已为 Electron 就绪!')
      return true
    } catch {
      console.log('⚠️  electron-rebuild 失败，尝试使用 realm 自身安装脚本...')
      // 使用 realm 包自身的 install 脚本并指定 runtime=electron
      const electronPkgJson = JSON.parse(fs.readFileSync('package.json', 'utf8'))
      const electronVersion =
        (electronPkgJson.devDependencies && electronPkgJson.devDependencies.electron) || ''
      const versionMatch = /\d+\.\d+\.\d+/.exec(electronVersion)
      const targetVersion = versionMatch ? versionMatch[0] : ''

      const env2 = {
        ...env,
        npm_config_runtime: 'electron',
        npm_config_target: targetVersion,
        npm_config_disturl: 'https://electronjs.org/headers'
      }

      execSync('npm run install', {
        cwd: realmPath,
        stdio: 'inherit',
        timeout: 600_000,
        env: env2
      })
      console.log('✅ 通过 realm 安装脚本完成 Electron 预编译!')
      return true
    }
  } catch (error) {
    console.error('❌ 为 Electron 准备 Realm 失败:', error.message)
    console.error('   可手动尝试: npx @electron/rebuild -f -w realm')
    return false
  }
}

// 主逻辑
function main() {
  let hasErrors = false

  // 1. 配置代理
  configureProxy()

  // 2. 检查和修复 Electron
  console.log('\n🔧 检查 Electron 安装状态...')
  const electronPath = findElectronPath()

  if (electronPath) {
    console.log(`📍 找到 Electron 路径: ${electronPath}`)

    if (isElectronInstalled(electronPath)) {
      console.log('✅ Electron 已正确安装')
    } else {
      console.log('⚠️  Electron 未正确安装，开始修复...')
      const success = installElectron(electronPath)

      if (success) {
        console.log('🎉 Electron 安装修复完成!')
      } else {
        console.error('❌ Electron 安装修复失败')
        hasErrors = true
      }
    }
  } else {
    console.log('⚠️  未找到 Electron 包，跳过检查')
  }

  // 3. 检查 Realm 原生模块（为 Electron 准备预编译/重建）
  console.log('\n🔧 检查 Realm 原生模块状态...')
  const realmPath = findRealmPath()
  if (realmPath) {
    console.log(`📍 找到 Realm 路径: ${realmPath}`)
    if (isRealmReadyForElectron(realmPath)) {
      console.log('✅ 已检测到 Electron 预编译二进制，跳过重建')
    } else {
      console.log('⚠️  未检测到 Electron 预编译，开始为 Electron 准备 Realm...')
      const ok = rebuildRealmForElectron(realmPath)
      if (!ok) {
        console.error('❌ Realm 为 Electron 的准备失败')
        hasErrors = true
      }
    }
  } else {
    console.log('⚠️  未找到 Realm 包，跳过检查')
  }

  // 4. 总结
  if (hasErrors) {
    console.error('\n❌ 部分依赖安装失败')
    console.error('   请手动运行: pnpm config set ignore-scripts false && pnpm install --force')
    process.exit(1)
  } else {
    console.log('\n🎉 所有依赖安装检查完成!')
  }
}

// 直接运行主函数
main()

export {
  configureProxy,
  findElectronPath,
  findRealmPath,
  installElectron,
  isElectronInstalled,
  isRealmReadyForElectron,
  rebuildRealmForElectron
}
